/**
 * 用户状态管理
 */
import { defineStore } from 'pinia';
import { userApi } from '@/api';
import { setToken, getToken, removeToken } from '@/utils/auth';
import { setStorage, getStorage, removeStorage } from '@/utils/storage';

export const useUserStore = defineStore('user', {
  state: () => ({
    token: getToken(),
    userInfo: getStorage('userInfo', null),
    addresses: getStorage('addresses', [])
  }),
  
  getters: {
    // 是否已登录
    isLogin(state) {
      return !!state.token && !!state.userInfo;
    },
    
    // 获取默认地址
    defaultAddress(state) {
      return state.addresses.find(item => item.isDefault) || (state.addresses[0] || null);
    }
  },
  
  actions: {
    // 登录
    async login(params) {
      try {
        const res = await userApi.login(params);
        
        // 处理接口返回数据，适配API文档
        if (res.code === 200 && res.token) {
          // 设置token
          this.token = res.token;
          setToken(res.token);
          
          // 获取用户信息
          await this.getUserInfo();
          
          return res;
        } else {
          return Promise.reject(res.msg || '登录失败');
        }
      } catch (error) {
        console.error('登录失败', error);
        return Promise.reject(error);
      }
    },
    
    // 注册
    async register(params) {
      try {
        const res = await userApi.register(params);
        
        if (res.code === 200) {
          return res;
        } else {
          return Promise.reject(res.msg || '注册失败');
        }
      } catch (error) {
        console.error('注册失败', error);
        return Promise.reject(error);
      }
    },
    
    // 获取用户信息
    async getUserInfo() {
      if (!this.token) return Promise.reject('暂未登录');
      
      try {
        const res = await userApi.getUserInfo();
        
        if (res.code === 200 && res.userInfo) {
          this.userInfo = res.userInfo;
          setStorage('userInfo', this.userInfo);
          return this.userInfo;
        } else {
          // 如果获取用户信息失败，清除token
          this.logout();
          return Promise.reject(res.msg || '获取用户信息失败');
        }
      } catch (error) {
        // 模拟数据
        if (process.env.NODE_ENV === 'development') {
          console.log('接口未实现，使用模拟数据');
          const mockUserInfo = {
            id: '1001',
            username: 'test_user',
            nickname: '测试用户',
            avatar: '/static/images/avatar.png',
            phone: '13800138000',
            gender: 1,
            birthday: '2000-01-01'
          };
          this.userInfo = mockUserInfo;
          setStorage('userInfo', mockUserInfo);
          return mockUserInfo;
        }
        
        console.error('获取用户信息失败', error);
        // 用户信息获取失败时，不应自动退出
        return Promise.reject(error);
      }
    },
    
    // 更新用户信息
    async updateUserInfo(params) {
      if (!this.token) return Promise.reject('暂未登录');
      
      try {
        const res = await userApi.updateUserInfo(params);
        
        if (res.code === 200 && res.userInfo) {
          this.userInfo = { ...this.userInfo, ...res.userInfo };
          setStorage('userInfo', this.userInfo);
          return this.userInfo;
        } else {
          return Promise.reject(res.msg || '更新用户信息失败');
        }
      } catch (error) {
        console.log('接口未实现，使用本地数据更新');
        
        // 更新本地用户信息
        this.userInfo = { ...this.userInfo, ...params };
        setStorage('userInfo', this.userInfo);
        
        return this.userInfo;
      }
    },
    
    // 修改密码
    async changePassword(params) {
      if (!this.token) return Promise.reject('暂未登录');
      
      try {
        const res = await userApi.changePassword(params);
        
        if (res.code === 200) {
          // 修改密码成功后，可以选择是否需要重新登录
          return res;
        } else {
          return Promise.reject(res.msg || '修改密码失败');
        }
      } catch (error) {
        console.error('修改密码失败', error);
        return Promise.reject(error);
      }
    },
    
    // 登出
    async logout() {
      try {
        // 尝试调用登出接口
        try {
          await userApi.logout();
        } catch (error) {
          console.log('登出接口未实现');
        }
        
        // 清除本地存储
        this.token = '';
        this.userInfo = null;
        removeToken();
        removeStorage('userInfo');
        
        return true;
      } catch (error) {
        console.error('登出失败', error);
        return Promise.reject(error);
      }
    },
    
    // 获取收货地址列表
    async getAddressList() {
      if (!this.token) return Promise.reject('暂未登录');
      
      try {
        const res = await userApi.getAddressList();
        
        if (res.code === 200 && res.addresses) {
          this.addresses = res.addresses;
          setStorage('addresses', this.addresses);
          return this.addresses;
        } else {
          return Promise.reject(res.msg || '获取地址列表失败');
        }
      } catch (error) {
        console.log('接口未实现，使用本地地址数据');
        
        // 使用本地存储的地址
        this.addresses = getStorage('addresses', []);
        return this.addresses;
      }
    },
    
    // 添加收货地址
    async addAddress(address) {
      if (!this.token) return Promise.reject('暂未登录');
      
      try {
        const res = await userApi.addAddress(address);
        
        if (res.code === 200 && res.address) {
          // 如果设置了默认地址，需要更新其他地址的默认状态
          if (address.isDefault) {
            this.addresses.forEach(item => {
              item.isDefault = false;
            });
          }
          
          this.addresses.push(res.address);
          setStorage('addresses', this.addresses);
          return res.address;
        } else {
          return Promise.reject(res.msg || '添加收货地址失败');
        }
      } catch (error) {
        console.log('接口未实现，使用本地数据添加地址');
        
        // 生成一个本地地址ID
        const newAddress = {
          ...address,
          id: Date.now().toString()
        };
        
        // 如果设置了默认地址，需要更新其他地址的默认状态
        if (newAddress.isDefault) {
          this.addresses.forEach(item => {
            item.isDefault = false;
          });
        }
        
        this.addresses.push(newAddress);
        setStorage('addresses', this.addresses);
        
        return newAddress;
      }
    },
    
    // 更新收货地址
    async updateAddress(address) {
      if (!this.token) return Promise.reject('暂未登录');
      
      try {
        const res = await userApi.updateAddress(address);
        
        if (res.code === 200) {
          const index = this.addresses.findIndex(item => item.id === address.id);
          if (index !== -1) {
            // 如果设置了默认地址，需要更新其他地址的默认状态
            if (address.isDefault) {
              this.addresses.forEach(item => {
                item.isDefault = false;
              });
            }
            
            this.addresses[index] = { ...this.addresses[index], ...address };
            setStorage('addresses', this.addresses);
          }
          
          return this.addresses[index];
        } else {
          return Promise.reject(res.msg || '更新收货地址失败');
        }
      } catch (error) {
        console.log('接口未实现，使用本地数据更新地址');
        
        const index = this.addresses.findIndex(item => item.id === address.id);
        if (index !== -1) {
          // 如果设置了默认地址，需要更新其他地址的默认状态
          if (address.isDefault) {
            this.addresses.forEach(item => {
              item.isDefault = false;
            });
          }
          
          this.addresses[index] = { ...this.addresses[index], ...address };
          setStorage('addresses', this.addresses);
          
          return this.addresses[index];
        }
        
        return Promise.reject('地址不存在');
      }
    },
    
    // 删除收货地址
    async deleteAddress(id) {
      if (!this.token) return Promise.reject('暂未登录');
      
      try {
        const res = await userApi.deleteAddress(id);
        
        if (res.code === 200) {
          this.addresses = this.addresses.filter(item => item.id !== id);
          setStorage('addresses', this.addresses);
          return true;
        } else {
          return Promise.reject(res.msg || '删除收货地址失败');
        }
      } catch (error) {
        console.log('接口未实现，使用本地数据删除地址');
        
        this.addresses = this.addresses.filter(item => item.id !== id);
        setStorage('addresses', this.addresses);
        
        return true;
      }
    },
    
    // 设置默认收货地址
    async setDefaultAddress(id) {
      if (!this.token) return Promise.reject('暂未登录');
      
      try {
        const res = await userApi.setDefaultAddress(id);
        
        if (res.code === 200) {
          this.addresses.forEach(item => {
            item.isDefault = item.id === id;
          });
          
          setStorage('addresses', this.addresses);
          return true;
        } else {
          return Promise.reject(res.msg || '设置默认地址失败');
        }
      } catch (error) {
        console.log('接口未实现，使用本地数据设置默认地址');
        
        this.addresses.forEach(item => {
          item.isDefault = item.id === id;
        });
        
        setStorage('addresses', this.addresses);
        return true;
      }
    }
  }
}); 